package com.cx.lambda;

import com.sun.corba.se.impl.orbutil.ObjectStreamClass_1_3_1;

import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @author zhangshuai
 * @version V1.0
 * @Project Java2_26
 * @Package com.cx.lambda
 * @Description:
 * @Date 2025/5/22 14:52
 */

public class Demo {

    //方法引用：
    //方法引用是Lambda表达式的一种简化形式，它用于直接引用现有的方法。
    //方法引用的语法是：类名::方法名
    //方法引用的类型有以下几种：
    //静态方法引用：ClassName::staticMethod
    //实例方法引用：instance::instanceMethod
    //构造方法引用：ClassName::new
    //数组构造方法引用：Type[]::new

    public static void main(String[] args) {

        MyInte myInte = (id,name)->System.out.println(id+name);
        myInte.test(1,"zs");
        //方法引用
//        MyInte myInte1 = Syu::test;

        //实例方法引用
        Syu syu = new Syu();
//        Consumer<String> consumer = (s)->syu.test(s);
//        Consumer<String> consumer1 = syu::test;

        // 类实例方法引用
        MyInte myInte2 = (id,name)->System.out.println(id+name);
        MyInte myInte3 = Syu::test;

        // new 对象引用
        Supplier<Syu> supplier = ()->new Syu();
        Supplier<Syu> supplier1 = Syu::new;

        //静态方法引用  如果参数列表一致，可以省略
           Demo.staticMethod(1,"zs");
           //lambda表达式写法
           Comparator<Integer> comparator = (o1,o2)->Integer.compare(o1,o2);
           //方法引用写法  参数列表可以省略  可读性非常差
           Comparator<Integer> comparator1 = Integer::compare;
           //消费型 //实例方法引用
           Consumer<Integer> consumer = (o1)->System.out.println(o1);
           Consumer<Integer> consumer1 = System.out::println; consumer1.accept(1);
            //构造方法引用：ClassName::new
           //供给型
          /*  Supplier<Syu> supplier = ()->new Syu();
            Supplier<Syu> supplier1 = Syu::new;
*/
            //        数组构造方法引用：Type[]::new
            //        函数式接口
        Syu[] syus = {new Syu("zs"), new Syu("ls")};
        //lambda表达式写法

        new Function<Integer,Syu[]>(){
            @Override
            public Syu[] apply(Integer s) {
                return new Syu[s];
            }
        };

        Function<Integer,Syu[]> function = (n)->new Syu[n];
        Syu[] syus2 = function.apply(2);
        syus2[0] = new Syu("zs");
        syus2[1] = new Syu("ls");
       /* for (Syu syu : syus2) {
            System.out.println(syu);
        }*/

        Function<Integer,Syu[]> function1 = Syu[]::new;
        Syu[] syus1 = function1.apply(2);



    }

    private static void staticMethod(int i, String s) {
        System.out.println("id:"+i+"name:"+s);
    }
}

class Syu{
    public static void test(int id, String name){
        System.out.println("name:"+name);
    }
    public Syu(){
        System.out.println("无参构造");
    }
    public Syu(String name){
        System.out.println("有参构造");
    }
}

interface MyInte{
    void test(int id,String name);
}